home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / dev / gui / MultiDesktop.lha / MultiDesktop / N < prev    next >
Encoding:
Text File  |  1997-03-27  |  23.7 KB  |  968 lines
  1. /* Gadgets */
  2. #include "multiwindows.h"
  3.  
  4. extern struct ExecBase         *SysBase;
  5. extern struct MultiWindowsBase *MultiWindowsBase;
  6.  
  7. struct MultiMessage *CheckMultiMessageSignals();
  8. void CallAction();
  9. void CallItem();
  10. void RawKey();
  11.  
  12. /* ---- AmigaGuide-Message behandeln */
  13. void HandleGuideMessage()
  14. {
  15.  struct MultiWindowsUser *mw;
  16.  struct AmigaGuideMsg    *agm;
  17.  ULONG                    type;
  18.  
  19.  
  20.  USER;
  21.  agm=GetAmigaGuideMsg(mw->Guide);
  22.  if(agm)
  23.   {
  24.    type=agm->agm_Type;
  25.    ReplyAmigaGuideMsg(agm);
  26.   }
  27.  
  28.  if(mw->GuideCommand)
  29.   {
  30.    if(type==ActiveToolID)
  31.     {
  32.      SendAmigaGuideContext(mw->Guide,NULL);
  33.      mw->GuideCommand=FALSE;
  34.      mw->GuideReady=TRUE;
  35.     }
  36.   }
  37. }
  38.  
  39. /* ---- Message vom Timer-Device holen */
  40. struct MultiMessage *GetTimerMessage(wait)
  41.  BOOL wait;
  42. {
  43.  struct MultiWindowsUser *mw;
  44.  struct MultiMessage     *mm;
  45.  BOOL                     bool;
  46.  int                      i;
  47.  
  48.  USER;
  49.  if(wait) WaitAlarm();
  50.  bool=CheckAlarm();
  51.  if(bool)
  52.   {
  53.    mm=&mw->MultiMessage;
  54.    mm->Class=MULTI_TIMERALARM;
  55.    mm->ObjectID=0;
  56.    mm->WindowID=0;
  57.    mm->ObjectCode=0;
  58.    for(i=0;i<4;i++)
  59.      mm->ObjectData[i]=0;
  60.    mm->ObjectAddress=NULL;
  61.    return(mm);
  62.   }
  63.  return(NULL);
  64. }
  65.  
  66. /* ---- System-Message holen */
  67. struct MultiMessage *GetSystemMessage(wait)
  68.  BOOL wait;
  69. {
  70.  struct MultiWindowsUser *mw;
  71.  struct MultiMessage     *mm;
  72.  ULONG                    Signals;
  73.  int                      i;
  74.  
  75.  USER;
  76.  if(wait) Signals=Wait(SIGBREAK); else Signals=SetSignal(0,0);
  77.  if(Signals & SIGBREAK)
  78.   {
  79.    mm=&mw->MultiMessage;
  80.    mm->Class=MULTI_SYSTEM;
  81.    i=0;
  82.    if(Signals & SIGBREAKF_CTRL_C) i=MSYS_BREAK_CTRL_C;
  83.    if(Signals & SIGBREAKF_CTRL_D) i+=MSYS_BREAK_CTRL_D;
  84.    if(Signals & SIGBREAKF_CTRL_E) i+=MSYS_BREAK_CTRL_E;
  85.    if(Signals & SIGBREAKF_CTRL_F) i+=MSYS_BREAK_CTRL_F;
  86.    mm->ObjectID=i;
  87.    mm->WindowID=0;
  88.    mm->ObjectCode=0;
  89.    for(i=0;i<4;i++)
  90.      mm->ObjectData[i]=0;
  91.    mm->ObjectAddress=NULL;
  92.    return(mm);
  93.   }
  94.  return(NULL);
  95. }
  96.  
  97. /* ---- Error-Message holen */
  98. struct MultiMessage *GetErrorMessage()
  99. {
  100.  struct MultiWindowsUser *mw;
  101.  struct MultiMessage     *mm;
  102.  BOOL                     guru;
  103.  ULONG                    error;
  104.  int                      i;
  105.  
  106.  USER;
  107.  guru=TRUE;
  108.  error=GetGuru();
  109.  if(error==0) { error=GetError(); guru=FALSE; }
  110.  if(error!=0)
  111.   {
  112.    mm=&mw->MultiMessage;
  113.    if(guru) mm->Class=MULTI_GURU; else mm->Class=MULTI_ERROR;
  114.    mm->ObjectID=error;
  115.    mm->WindowID=0;
  116.    mm->ObjectCode=0;
  117.    for(i=0;i<4;i++)
  118.      mm->ObjectData[i]=0;
  119.    mm->ObjectAddress=NULL;
  120.    return(mm);
  121.   }
  122.  return(NULL);
  123. }
  124.  
  125. /* ---- Message vom AppPort holen */
  126. struct MultiMessage *GetAppMessage(wait)
  127.  BOOL wait;
  128. {
  129.  struct MultiWindowsUser *mw;
  130.  struct MultiMessage     *mm;
  131.  struct AppMessage       *app;
  132.  struct AppObject        *ao;
  133.  struct ScreenEntry      *se;
  134.  struct WindowEntry      *we;
  135.  int                      i;
  136.  
  137.  USER;
  138.  if(wait) WaitPort(mw->AppPort);
  139.  app=GetMsg(mw->AppPort);
  140.  if(app)
  141.   {
  142.    CopyMemQuick(app,&mw->AppMessage,sizeof(struct AppMessage));
  143.    ReplyMsg(app);
  144.  
  145.    app=&mw->AppMessage;
  146.    mm=&mw->MultiMessage;
  147.    ao=app->am_UserData;
  148.  
  149.    mm->Class=MULTI_RAWAPPMESSAGE;
  150.    mm->AppMessage=&mw->AppMessage;
  151.    mm->ObjectID=0;
  152.    mm->WindowID=0;
  153.    mm->ObjectCode=0;
  154.    for(i=0;i<4;i++)
  155.      mm->ObjectData[i]=0;
  156.    mm->ObjectAddress=NULL;
  157.  
  158.    if(ao!=NULL)
  159.     {
  160.      mm->ObjectAddress=ao->Owner;
  161.      switch(ao->OwnerType)
  162.       {
  163.        case OT_SCREENENTRY:
  164.          se=ao->Owner;
  165.          mm->ObjectCode=APPCODE_SCREEN;
  166.          mm->ObjectID=se->ScreenID;
  167.         break;
  168.        case OT_WINDOWENTRY:
  169.          we=ao->Owner;
  170.          mm->ObjectCode=APPCODE_WINDOW;
  171.          mm->ObjectID=we->WindowID;
  172.          mm->WindowID=we->WindowID;
  173.         break;
  174.        default:
  175.          mm->ObjectCode=APPCODE_USER;
  176.         break;
  177.       }
  178.  
  179.      switch(app->am_Type)
  180.       {
  181.        case MTYPE_APPICON:
  182.          mm->Class=MULTI_APPICON;
  183.         break;
  184.        case MTYPE_APPMENUITEM:
  185.          mm->Class=MULTI_APPMENUITEM;
  186.         break;
  187.        case MTYPE_APPWINDOW:
  188.          mm->Class=MULTI_APPWINDOW;
  189.         break;
  190.       }
  191.     }
  192.  
  193.    return(mm);
  194.   }
  195.  return(NULL);
  196. }
  197.  
  198.  
  199. /* ---- IDCMP-Verwaltung */
  200. struct MultiMessage *GetWindowMessage(windowID,wait)
  201.  UBYTE windowID;
  202.  BOOL  wait;
  203. {
  204.  struct MultiWindowsUser *mw;
  205.  struct WindowEntry      *we;
  206.  struct IntuiMessage     *msg;
  207.  struct MultiMessage     *mm;
  208.  struct ActionMessage    *am;
  209.  int                      i;
  210.  
  211.  USER;
  212.  we=FindWindowEntry(windowID);
  213.  if(we)
  214.   {
  215.    mm=&mw->MultiMessage;
  216.    mm->Class=MULTI_RAWINTUIMESSAGE;
  217.    mm->IntuiMessage=&mw->IntuiMessage;
  218.    mm->ObjectID=0;
  219.    mm->WindowID=we->WindowID;
  220.    mm->ObjectCode=0;
  221.    for(i=0;i<4;i++)
  222.      mm->ObjectData[i]=0;
  223.    mm->ObjectAddress=NULL;
  224.  
  225.    if(!we->Iconify)
  226.     {
  227.      if(we->ActionMessage)
  228.       {
  229.        am=we->ActionMessage;
  230.  
  231.        mm->Class=am->Class;
  232.        mm->ObjectID=am->ObjectID;
  233.        mm->ObjectCode=am->ObjectCode;
  234.        mm->ObjectAddress=am->ObjectAddress;
  235.        mm->IntuiMessage=NULL;
  236.        we->ActionMessage=am->NextMessage;
  237.        if(we->ActionMessage) Signal(SysBase->ThisTask,(1L<<we->UserPort->mp_SigBit));
  238.  
  239.        FreeMemoryBlock(&we->Remember,am);
  240.        return(mm);
  241.       }
  242.  
  243.      if(wait) WaitPort(we->UserPort);
  244.      msg=GTGetIMsg(we->UserPort);
  245.      if(msg)
  246.       {
  247.        if(msg->Class==MENUVERIFY)
  248.          MenuVerify(we);
  249.        CopyMemQuick(msg,&mw->IntuiMessage,sizeof(struct IntuiMessage));
  250.        GTReplyIMsg(msg);
  251.        msg=&mw->IntuiMessage;
  252.  
  253.        switch(msg->Class)
  254.         {
  255.          case REFRESHWINDOW:
  256.            mm->Class=MULTI_REFRESHWINDOW;
  257.            mm->ObjectID=we->Window->WindowID;
  258.            mm->ObjectAddress=we;
  259.            GTBeginRefresh(we->Window);
  260.            RefreshSGadgets(we);
  261.            GTEndRefresh(we->Window,TRUE);
  262.           break;
  263.          case MOUSEMOVE:
  264.            MouseMove(we,msg,mm);
  265.           break;
  266.          case INTUITICKS:
  267.            IntuiTicks(we,msg,mm);
  268.           break;
  269.          case NEWSIZE:
  270.            mm->Class=MULTI_NEWSIZE;
  271.            mm->ObjectID=we->Window->WindowID;
  272.            mm->ObjectAddress=we;
  273.            NewSize(we);
  274.           break;
  275.          case CLOSEWINDOW:
  276.            mm->Class=MULTI_CLOSEWINDOW;
  277.            mm->ObjectID=we->Window->WindowID;
  278.            mm->ObjectAddress=we;
  279.           break;
  280.          case VANILLAKEY:
  281.            VanillaKey(we,msg,mm);
  282.           break;
  283.          case MENUPICK:
  284.            MenuPick(we,msg,mm);
  285.           break;
  286.          case RAWKEY:
  287.            RawKey(we,msg,mm);
  288.           break;
  289.          case GADGETUP:
  290.            GadgetUp(we,msg,mm);
  291.           break;
  292.          case GADGETDOWN:
  293.            GadgetDown(we,msg,mm);
  294.           break;
  295.          case INACTIVEWINDOW:
  296.            InactiveWindow(we,msg,mm);
  297.           break;
  298.          case ACTIVEWINDOW:
  299.            ActiveWindow(we,msg,mm);
  300.           break;
  301.          case NEWPREFS:
  302.            NewPrefs(we,msg,mm);
  303.           break;
  304.         }
  305.        return(mm);
  306.       }
  307.     }
  308.   }
  309.  return(NULL);
  310. }
  311.  
  312. /* ---- ActionList erstellen */
  313. BOOL MakeAction(targetID,sourceCode,targetCode)
  314.  ULONG targetID;
  315.  UBYTE sourceCode,targetCode;
  316. {
  317.  struct WindowEntry *we;
  318.  struct MWGadget    *gad;
  319.  struct Action      *action;
  320.  
  321.  WE;
  322.  if(we==NULL) return(FALSE);
  323.  gad=we->LastGadget;
  324.  if(gad==NULL)
  325.   {
  326.    ErrorL(1017,"MakeAction():\nThere's no valid gadget!");
  327.    return(FALSE);
  328.   }
  329.  
  330.  action=AllocMemory(&gad->Remember,sizeof(struct Action),MEMF_PUBLIC);
  331.  if(action==NULL)
  332.   {
  333.    NoMemory();
  334.    return(FALSE);
  335.   }
  336.  
  337.  action->TargetID=targetID;
  338.  action->SourceCode=sourceCode;
  339.  action->TargetCode=targetCode;
  340.  action->NextAction=gad->Action;
  341.  gad->Action=action;
  342. }
  343.  
  344. /* ---- Action-Liste entfernen */
  345. void UnMakeAction(gadgetID)
  346.  ULONG gadgetID;
  347. {
  348.  struct MWGadget *gad;
  349.  
  350.  gad=FindGadget(gadgetID);
  351.  if(gad!=NULL)
  352.   {
  353.    gad->Action=NULL;
  354.    FreeMemory(&gad->Remember);
  355.   }
  356. }
  357.  
  358. /* ---- ActionList ausführen */
  359. void CallAction(gad)
  360.  struct MWGadget *gad;
  361. {
  362.  struct ActionMessage *am;
  363.  struct Action        *action;
  364.  struct WindowEntry   *we;
  365.  ULONG                 code,code2,class;
  366.  BYTE                  windowID;
  367.  
  368.  we=gad->WindowEntry;
  369.  windowID=ActWin(we->WindowID);
  370.  
  371.  action=gad->Action;
  372.  while(action!=NULL)
  373.   {
  374.    switch(action->SourceCode)
  375.     {
  376.      case AGC_SLIDER:
  377.        code=AskSlider(gad->GadgetID);
  378.       break;
  379.      case AGC_SCROLLER:
  380.        code=AskScroller(gad->GadgetID);
  381.       break;
  382.      case AGC_WHEEL:
  383.        code=AskWheel(gad->GadgetID);
  384.       break;
  385.      case AGC_INTEGER:
  386.        code=AskInteger(gad->GadgetID);
  387.       break;
  388.      case AGC_STRING:
  389.        code=AskString(gad->GadgetID);
  390.       break;
  391.      case AGC_HEX:
  392.        code=AskHex(gad->GadgetID);
  393.       break;
  394.      case AGC_FLOAT:
  395.        code=AskFloat(gad->GadgetID);
  396.       break;
  397.      case AGC_CYCLE:
  398.        code=AskCycle(gad->GadgetID);
  399.       break;
  400.      case AGC_MX:
  401.        code=AskMX(gad->GadgetID);
  402.       break;
  403.      case AGC_SELECTBOX:
  404.        code=AskSelectBox(gad->GadgetID);
  405.       break;
  406.      case AGC_LISTVIEW_SELECTION:
  407.        code=AskListviewSelection(gad->GadgetID);
  408.       break;
  409.      case AGC_LISTVIEW_LABEL:
  410.        code=AskListviewSelectionLabel(gad->GadgetID);
  411.       break;
  412.      case AGC_LISTVIEW_REMTEXT:
  413.        code=AskListviewSelectionLabel(gad->GadgetID);
  414.        code2=AskListviewSelection(gad->GadgetID);
  415.       break;
  416.      case AGC_PALETTE:
  417.        code=AskPalette(gad->GadgetID);
  418.       break;
  419.      default:
  420.        GadErr(1020,"ActionList:\nInvalid SourceCode",gad);
  421.        ActWin(windowID);
  422.        return;
  423.       break;
  424.     }
  425.  
  426.    class=MULTI_GADGETUP;
  427.    switch(action->TargetCode)
  428.     {
  429.      case AGC_SLIDER:
  430.        class=MULTI_GADGETDOWN;
  431.        UpdateSlider(action->TargetID,code);
  432.       break;
  433.      case AGC_SCROLLER:
  434.        class=MULTI_GADGETDOWN;
  435.        UpdateScroller(action->TargetID,code,-1L,-1L);
  436.       break;
  437.      case AGC_WHEEL:
  438.        class=MULTI_GADGETDOWN;
  439.        UpdateWheel(action->TargetID,code);
  440.       break;
  441.      case AGC_MX:
  442.        class=MULTI_GADGETDOWN;
  443.        UpdateMX(action->TargetID,code);
  444.       break;
  445.      case AGC_SELECTBOX:
  446.        UpdateSelectBox(action->TargetID,code);
  447.       break;
  448.      case AGC_CYCLE:
  449.        UpdateCycle(action->TargetID,code);
  450.       break;
  451.      case AGC_LISTVIEW_SELECTION:
  452.        UpdateListviewSelection(action->TargetID,code);
  453.       break;
  454.      case AGC_LISTVIEW_ADDHEAD:
  455.        AddListviewEntrySort(action->TargetID,code,ULP_HEAD);
  456.        if(action->SourceCode==AGC_LISTVIEW_REMTEXT)
  457.          RemListviewEntryNumber(gad->GadgetID,code2);
  458.       break;
  459.      case AGC_LISTVIEW_ADDTAIL:
  460.        AddListviewEntrySort(action->TargetID,code,ULP_TAIL);
  461.        if(action->SourceCode==AGC_LISTVIEW_REMTEXT)
  462.          RemListviewEntryNumber(gad->GadgetID,code2);
  463.       break;
  464.      case AGC_LISTVIEW_ADDSORTD:
  465.        AddListviewEntrySort(action->TargetID,code,ULP_SORTD);
  466.        if(action->SourceCode==AGC_LISTVIEW_REMTEXT)
  467.          RemListviewEntryNumber(gad->GadgetID,code2);
  468.       break;
  469.      case AGC_LISTVIEW_ADDSORTA:
  470.        AddListviewEntrySort(action->TargetID,code,ULP_SORTA);
  471.        if(action->SourceCode==AGC_LISTVIEW_REMTEXT)
  472.          RemListviewEntryNumber(gad->GadgetID,code2);
  473.       break;
  474.      case AGC_LISTVIEW_CHANGESELECTEDLABEL:
  475.        ChangeListviewEntrySelected(action->TargetID,code);
  476.       break;
  477.      case AGC_NM:
  478.        UpdateNM(action->TargetID,code);
  479.       break;
  480.      case AGC_NUMBER:
  481.        UpdateNumber(action->TargetID,code);
  482.       break;
  483.      case AGC_TEXT:
  484.        UpdateText(action->TargetID,code);
  485.       break;
  486.      case AGC_TX:
  487.        UpdateText(action->TargetID,code);
  488.       break;
  489.      case AGC_STRING:
  490.        UpdateString(action->TargetID,code);
  491.       break;
  492.      case AGC_HEX:
  493.        UpdateHex(action->TargetID,code);
  494.       break;
  495.      case AGC_FLOAT:
  496.        UpdateFloat(action->TargetID,code);
  497.       break;
  498.      case AGC_INTEGER:
  499.        UpdateInteger(action->TargetID,code);
  500.       break;
  501.      case AGC_PALETTE:
  502.        UpdatePalette(action->TargetID,code);
  503.       break;
  504.      case AGC_STATUS:
  505.        UpdateStatus(action->TargetID,code);
  506.       break;
  507.      default:
  508.        GadErr(1019,"ActionList:\nInvalid TargetCode!",gad);
  509.        ActWin(windowID);
  510.        return;
  511.       break;
  512.     }
  513.  
  514.    am=AllocMemory(&we->Remember,sizeof(struct ActionMessage),MEMF_ANY);
  515.    if(am!=NULL)
  516.     {
  517.  
  518. printf("AM %ld\n",sizeof(struct ActionMessage));
  519.  
  520.      am->NextMessage=we->ActionMessage;
  521.      am->Class=class;
  522.      am->ObjectID=action->TargetID;
  523.      am->ObjectCode=code;
  524.      am->ObjectAddress=FindGadget(action->TargetID);
  525.      we->ActionMessage=am;
  526.     }
  527.    else NoMemory();
  528.  
  529.    action=action->NextAction;
  530.   }
  531.  
  532.  Signal(SysBase->ThisTask,(1L<<we->UserPort->mp_SigBit));
  533.  ActWin(windowID);
  534. }
  535.  
  536. /* ---- Gadget-Klick durch Tastendruck simulieren */
  537. void CallGadget(we,gad,mm,shifted)
  538.  struct WindowEntry  *we;
  539.  struct MWGadget     *gad;
  540.  struct MultiMessage *mm;
  541.  BOOL                 shifted;
  542. {
  543.  BYTE               windowID;
  544.  ULONG              j;
  545.  struct CycleData *cd;
  546.  long              i;
  547.  
  548.  windowID=ActWin(we->WindowID);
  549.  mm->IntuiMessage=NULL;
  550.  mm->ObjectID=gad->GadgetID;
  551.  switch(gad->Type)
  552.   {
  553.    case MWGAD_GADTOOLS:
  554.      switch(gad->Kind)
  555.       {
  556.        case MX_KIND:      /* ---- MX-Gadget ---------------- */
  557.          UpdateMX(gad->GadgetID,gad->CommandKey);
  558.          mm->Class=MULTI_GADGETDOWN;
  559.          mm->ObjectCode=gad->CommandKey;
  560.          gad->CommandKey=0x00;
  561.         break;
  562.        case CYCLE_KIND:   /* ---- Cycle-Gadget ------------- */
  563.          cd=gad->ExtData;
  564.          i=gad->TagList[CYCLE_ACTIVE].ti_Data;
  565.          if(shifted==FALSE)
  566.           { i++; if(i>=cd->LabelCount) i=0; }
  567.          else
  568.           { i--; if(i<0) i=cd->LabelCount-1; }
  569.          UpdateCycle(gad->GadgetID,i);
  570.          mm->Class=MULTI_GADGETUP;
  571.          mm->ObjectCode=i;
  572.         break;
  573.        case BUTTON_KIND:   /* ---- Boolean-Gadget ---------- */
  574.          mm->Class=MULTI_GADGETUP;
  575.         break;
  576.        case CHECKBOX_KIND: /* ---- Checkbox-Gadget --------- */
  577.          UpdateCheckbox(gad->GadgetID,!gad->TagList[CHECKBOX_CHECKED].ti_Data);
  578.          mm->Class=MULTI_GADGETDOWN;
  579.          mm->ObjectCode=gad->TagList[CHECKBOX_CHECKED].ti_Data;
  580.         break;
  581.        case STRING_KIND:   /* ---- String- oder Integer-     */
  582.        case INTEGER_KIND:  /*        Gadget ---------------- */
  583.          ActivateGadget(gad->Update,we->Window,NULL);
  584.         break;
  585.        case SLIDER_KIND:   /* ---- Slider-Gadget ----------- */
  586.          i=gad->TagList[SLIDER_LEVEL].ti_Data;
  587.          if(shifted==FALSE)
  588.            { if(i<gad->TagList[SLIDER_MAX].ti_Data) i++; }
  589.          else
  590.            { if(i>gad->TagList[SLIDER_MIN].ti_Data) i--; }
  591.          UpdateSlider(gad->GadgetID,i);
  592.          mm->Class=MULTI_GADGETDOWN;
  593.          mm->ObjectCode=i;
  594.         break;
  595.        case SCROLLER_KIND:   /* ---- Scroller-Gadget ------- */
  596.          i=gad->TagList[SCROLLER_TOP].ti_Data;
  597.          if(shifted==FALSE)
  598.            { if(i<gad->TagList[SCROLLER_VISIBLE].ti_Data) i++; }
  599.          else
  600.            { if(i>0) i--; }
  601.          UpdateScroller(gad->GadgetID,-1L,-1L,i);
  602.          mm->Class=MULTI_GADGETDOWN;
  603.          mm->ObjectCode=i;
  604.         break;
  605.        case LISTVIEW_KIND:     /* ---- Listview-Gadget ------ */
  606.          i=gad->TagList[LISTVIEW_SELECTED].ti_Data;
  607.          if(shifted==FALSE)
  608.            i++;
  609.          else
  610.            { if(i>0) i--; }
  611.          UpdateListviewSelection(gad->GadgetID,i);
  612.          mm->Class=MULTI_GADGETDOWN;
  613.          mm->ObjectCode=i;
  614.         break;
  615.        case PALETTE_KIND:     /* ---- Palette-Gadget ------- */
  616.          i=gad->TagList[PALETTE_COLOR].ti_Data;
  617.          if(shifted==FALSE)
  618.            { if(i<2^(gad->TagList[PALETTE_DEPTH].ti_Data)) i++; }
  619.          else
  620.            { if(i>gad->TagList[PALETTE_OFFSET].ti_Data) i--; }
  621.          UpdatePalette(gad->GadgetID,i);
  622.          mm->Class=MULTI_GADGETDOWN;
  623.          mm->ObjectCode=i;
  624.         break;
  625.       }
  626.     break;
  627.    case MWGAD_SPECIAL:
  628.      switch(gad->Kind)
  629.       {
  630.        case WHEEL_KIND:
  631.          j=AskWheel(gad->GadgetID);
  632.          if(shifted==FALSE)
  633.            UpdateWheel(gad->GadgetID,j+1);
  634.          else
  635.            UpdateWheel(gad->GadgetID,j-1);
  636.          mm->Class=MULTI_GADGETUP;
  637.          mm->ObjectCode=AskWheel(gad->GadgetID);
  638.         break;
  639.        case SELECTBOX_KIND:
  640.          SelectBoxHandler(gad,mm);
  641.         break;
  642.        case CLICKBOX_KIND:
  643.          mm->Class=MULTI_GADGETUP;
  644.          if(gad->TagList[CLICKBOX_STATUS].ti_Data)
  645.            mm->ObjectCode=FALSE;
  646.          else
  647.            mm->ObjectCode=TRUE;
  648.          UpdateClickBox(gad->GadgetID,mm->ObjectCode);
  649.         break;
  650.       }
  651.     break;
  652.   }
  653.  if(gad->Action) CallAction(gad);
  654.  ActWin(windowID);
  655. }
  656.  
  657. /* ---- Gadget erneuern */
  658. void UpdateGadget(gad)
  659.  struct MWGadget *gad;
  660. {
  661.  struct MultiWindowsUser *mw;
  662.  struct WindowEntry      *we;
  663.  struct StringInfo       *si;
  664.  struct StringData       *sd;
  665.  struct IconData         *id;
  666.  
  667.  USER;
  668.  we=gad->WindowEntry;
  669.  if(gad->Gadget) RemoveGList(we->Window,gad->Gadget,gad->GadgetCount);
  670.  switch(gad->Type)
  671.   {
  672.    case MWGAD_GADTOOLS:
  673.      if(gad->Update)
  674.       {
  675.        switch(gad->Kind)
  676.         {
  677.          case STRING_KIND:
  678.            si=gad->Update->SpecialInfo;
  679.            sd=gad->ExtData;
  680.            strcpy(sd->Buffer,si->Buffer);
  681.           break;
  682.          case INTEGER_KIND:
  683.            si=gad->Update->SpecialInfo;
  684.            gad->TagList[INTEGER_INTEGER].ti_Data=atol(si->Buffer);
  685.           break;
  686.         }
  687.       }
  688.  
  689.      if(gad->Gadget) FreeGList(gad->Gadget,gad->GadgetCount);
  690.      gad->Gadget=NULL;
  691.      gad->Gadget=CreateContext(&gad->Gadget);
  692.      if(gad->Gadget==NULL)
  693.       NoMemory();
  694.      else
  695.       {
  696.        gad->Update=CreateGadgetA(gad->Kind,gad->Gadget,&gad->NewGadget,&gad->TagList);
  697.        if(gad->Update==NULL)
  698.         {
  699.          FreeGList(gad->Gadget,gad->GadgetCount);
  700.          gad->Gadget=NULL;
  701.          NoMemory();
  702.         }
  703.        else
  704.         {
  705.          if(gad->Type==MWGAD_GADTOOLS)
  706.           {
  707.            switch(gad->Kind)
  708.             {
  709.               case BUTTON_KIND:
  710.                 if(gad->ExtData==TOGGLE_MAGIC) {
  711.                   gad->Update->Activation |= TOGGLESELECT;
  712.                   if(gad->TagList[TOGGLE_STATUS].ti_Data==TRUE)
  713.                     gad->Update->Flags |= SELECTED; }
  714.               break;
  715.              case MX_KIND:
  716.                if(gad->TagList[GADGET_DISABLE].ti_Data==TRUE)
  717.                  DisableGad(gad->Gadget);
  718.                MXResize(we,gad);
  719.               break;
  720.              case LISTVIEW_KIND:
  721.                LVResize(we,gad);
  722.               break;
  723.              case STRING_KIND:
  724.                AddHook(gad);
  725.                if(gad->Update->GadgetText)
  726.                  gad->Update->GadgetText->ITextFont=mw->TextAttr;
  727.               break;
  728.              case INTEGER_KIND:
  729.                if(gad->Update->GadgetText)
  730.                  gad->Update->GadgetText->ITextFont=mw->TextAttr;
  731.               break;
  732.             }
  733.           }
  734.  
  735.          ClearGad(we,gad);
  736.  
  737.          gad->Update->UserData=gad;
  738.          gad->GadgetCount=CountGadgets(gad->Gadget);
  739.          AddGList(we->Window,gad->Gadget,0,gad->GadgetCount,NULL);
  740.         }
  741.       }
  742.     break;
  743.    case MWGAD_SPECIAL:
  744.      if(gad->Gadget)
  745.       {
  746.        InitGadget(gad,gad->Gadget,FALSE);
  747.        switch(gad->Kind)
  748.         {
  749.          case ICON_KIND:
  750.            id=gad->ExtData;
  751.            if(id->Icon)
  752.             {
  753.              id->Gadget.GadgetRender=CenterImage(id->Icon->do_Gadget.GadgetRender,
  754.                                                 gad->NewGadget.ng_Width,
  755.                                                 gad->NewGadget.ng_Height);
  756.              id->Gadget.SelectRender=CenterImage(id->Icon->do_Gadget.SelectRender,
  757.                                                  gad->NewGadget.ng_Width,
  758.                                                  gad->NewGadget.ng_Height);
  759.             }
  760.           break;
  761.          case IMAGE_KIND:
  762.            gad->Gadget->GadgetRender=CenterImage(gad->Gadget->GadgetRender,
  763.                                                  gad->NewGadget.ng_Width,
  764.                                                  gad->NewGadget.ng_Height);
  765.            gad->Gadget->SelectRender=CenterImage(gad->Gadget->SelectRender,
  766.                                                  gad->NewGadget.ng_Width,
  767.                                                  gad->NewGadget.ng_Height);
  768.           break;
  769.         }
  770.        AddGList(we->Window,gad->Gadget,0,gad->GadgetCount,NULL);
  771.       }
  772.     break;
  773.   }
  774. }
  775.  
  776. /* ---- Taste wurde gedrückt (RawKey) */
  777. void RawKey(we,msg,mm)
  778.  struct WindowEntry  *we;
  779.  struct IntuiMessage *msg;
  780.  struct MultiMessage *mm;
  781. {
  782.  struct MWMenuItem *item;
  783.  
  784.  item=FindKeyItem(we,msg->Code,msg->Qualifier,TRUE);
  785.  if(item!=NULL)
  786.   {
  787.    CallItem(we,item);
  788.  
  789.    mm->Class=MULTI_MENUPICK;
  790.    mm->ObjectID=item->ItemID;
  791.    mm->ObjectAddress=item;
  792.    if(item->MenuItem.Flags & CHECKED) mm->ObjectCode=TRUE;
  793.  
  794.    SysItemHandler(item);
  795.   }
  796.  else
  797.   {
  798.    mm->Class=MULTI_RAWKEY;
  799.    mm->ObjectID=(ULONG)msg->Code;
  800.    mm->ObjectCode=msg->Qualifier;
  801.    mm->ObjectAddress=we;
  802.   }
  803. }
  804.  
  805. /* ---- Window-Signalliste erstellen */
  806. struct SignalList *GetSignalList()
  807. {
  808.  struct SignalList       *sl;
  809.  struct MultiWindowsUser *mw;
  810.  struct MultiDesktopUser *mu;
  811.  struct WindowEntry      *we;
  812.  int                      i;
  813.  
  814.  USER;
  815.  mu=SysBase->ThisTask->tc_UserData;
  816.  
  817.  sl=&mw->SignalList;
  818.  sl->Count=0;
  819.  sl->WaitMask=0L;
  820.  sl->MenuInUse=FALSE;
  821.  
  822.  for(i=0;i<MAXWINDOWS;i++)
  823.   {
  824.    we=mw->WindowList[i];
  825.    if((we!=NULL)&&(we->UserPort!=NULL))
  826.     {
  827.      sl->WindowID[sl->Count]=we->WindowID;
  828.      if(we->MenuInUse) sl->MenuInUse=TRUE;
  829.      sl->SignalMask[sl->Count]=(1L<<we->UserPort->mp_SigBit);
  830.      sl->WaitMask+=sl->SignalMask[sl->Count];
  831.      sl->Count++;
  832.     }
  833.   }
  834.  
  835.  sl->TimerSignalMask=(1L<<mu->TimerPort->mp_SigBit);
  836.  sl->AppSignalMask=(1L<<mw->AppPort->mp_SigBit);
  837.  sl->GuideSignalMask=mw->GuideSignalMask;
  838.  sl->BreakSignalMask=SIGBREAK;
  839.  
  840.  sl->WaitMask=sl->WaitMask |
  841.                sl->TimerSignalMask |
  842.                sl->AppSignalMask |
  843.                sl->GuideSignalMask |
  844.                sl->BreakSignalMask;
  845.  return(sl);
  846. }
  847.  
  848. /* ---- Signalmaske ermitteln */
  849. ULONG GetSignalMask()
  850. {
  851.  struct SignalList *sl;
  852.  
  853.  sl=GetSignalList();
  854.  return(sl->WaitMask);
  855. }
  856.  
  857. /* ---- Alle Windows und App-Port abfragen */
  858. struct MultiMessage *GetMultiMessage(wait)
  859.  BOOL wait;
  860. {
  861.  ULONG                    Signals;
  862.  struct MultiDesktopUser *mu;
  863.  struct MultiWindowsUser *mw;
  864.  struct MultiMessage     *mm;
  865.  struct SignalList       *sl;
  866.  int                      i;
  867.  
  868.  mm=GetErrorMessage();
  869.  if(mm) return(mm);
  870.  
  871.  USER;
  872.  mu=SysBase->ThisTask->tc_UserData;
  873.  
  874.  sl=GetSignalList();
  875.  
  876.  if(wait)
  877.    Signals=Wait(sl->WaitMask);
  878.  else
  879.    Signals=SetSignal(0L,0L);
  880.  
  881.  return(CheckMultiMessageSignals(Signals));
  882. }
  883.  
  884. /* ---- Signale verarbeiten */
  885. struct MultiMessage *CheckMultiMessageSignals(Signals)
  886.  ULONG Signals;
  887. {
  888.  struct MultiDesktopUser *mu;
  889.  struct MultiWindowsUser *mw;
  890.  struct MultiMessage     *mm;
  891.  struct SignalList       *sl;
  892.  int                      i;
  893.  
  894.  mm=GetErrorMessage();
  895.  if(mm) return(mm);
  896.  
  897.  USER;
  898.  mu=SysBase->ThisTask->tc_UserData;
  899.  
  900.  sl=GetSignalList();
  901.  if(Signals & sl->BreakSignalMask)
  902.   {
  903.    mm=&mw->MultiMessage;
  904.    mm->Class=MULTI_SYSTEM;
  905.    i=0;
  906.    if(Signals & SIGBREAKF_CTRL_C) i=MSYS_BREAK_CTRL_C;
  907.    if(Signals & SIGBREAKF_CTRL_D) i+=MSYS_BREAK_CTRL_D;
  908.    if(Signals & SIGBREAKF_CTRL_E) i+=MSYS_BREAK_CTRL_E;
  909.    if(Signals & SIGBREAKF_CTRL_F) i+=MSYS_BREAK_CTRL_F;
  910.    mm->ObjectID=i;
  911.    mm->WindowID=0;
  912.    mm->ObjectCode=0;
  913.    for(i=0;i<4;i++)
  914.      mm->ObjectData[i]=0;
  915.    mm->ObjectAddress=NULL;
  916.    return(mm);
  917.   }
  918.  
  919.  if((sl->GuideSignalMask!=0L) && (Signals & sl->GuideSignalMask))
  920.    HandleGuideMessage();
  921.  
  922.  if(Signals & sl->AppSignalMask)
  923.   {
  924.    mm=GetAppMessage(FALSE);
  925.    if(mm!=NULL)
  926.     {
  927.      Signals &= ~sl->AppSignalMask;
  928.      Signal(SysBase->ThisTask,Signals);
  929.      return(mm);
  930.     }
  931.   }
  932.  
  933.  if(Signals & sl->TimerSignalMask)
  934.   {
  935.    if(!sl->MenuInUse)
  936.     {
  937.      mm=GetTimerMessage(FALSE);
  938.      if(mm!=NULL)
  939.       {
  940.        Signals &= ~sl->TimerSignalMask;
  941.        Signal(SysBase->ThisTask,Signals);
  942.        return(mm);
  943.       }
  944.     }
  945.    else
  946.     Signal(SysBase->ThisTask,sl->TimerSignalMask);
  947.   }
  948.  
  949.  for(i=0;i<sl->Count;i++)
  950.   {
  951.    if(Signals & sl->SignalMask[i])
  952.     {
  953.      mm=GetWindowMessage(sl->WindowID[i],FALSE);
  954.      if(mm!=NULL)
  955.       {
  956.        for( ;i<sl->Count;i++)
  957.         {
  958.          if(Signals & sl->SignalMask[i])
  959.            Signal(SysBase->ThisTask,sl->SignalMask[i]);
  960.         }
  961.        return(mm);
  962.       }
  963.     }
  964.   }
  965.  return(NULL);
  966. }
  967.  
  968.